A transaction is considered a unit of work, which includes a plurality of requested services, such as a plurality of computer programs or applications. Each application is developed using a programming language. During the course of programming, errors may occur due to programmer error. These errors include either syntax errors or logic errors. Syntax errors are caught by the compiler, which refuses to generate machine instructions for a line of programming language that it does not understand. Logic errors, however, are detected when the application does not perform as expected, often resulting in program exceptions or incorrect behavior.
While syntax errors can be corrected by determining the correct syntax, logic errors are often much more difficult to ascertain. For this reason, a special class of computer programs was developed. These programs are called debuggers. A debugger allows the user to trace through a program, while it is executing on the computer, often in the original human-readable text format originally used in the programming language. This allows the programmer to determine the instance or instances where the logical flow of the program is incorrectly designed.
Traditional debuggers run on a given application with a fixed starting and ending point, and only run on the machine where the application was started. These debuggers have proven inadequate, however, for distributed applications and for transactions that span across processors. For example, for many server transactions, the data required to satisfy a given request may not reside on the server to which the request was sent. To satisfy the request, the server initiates a request to another server, which may or may not initiate another request, until information is gathered to satisfy the initial request. While this provides a friendly environment for the end user of the transaction, it is a difficult environment on which to build the transaction.
Some debuggers have been enhanced in order to be able to debug a distributed application that executes on multiple processors. With those debuggers, however, each processor to run the application needs to be known in advance, and a debug registration process needs to be performed on each of the processors. This has proved inadequate, especially for transactions that span processors.
Based on the foregoing, a need still exists for a capability that allows a transaction to be debugged across a plurality of processors. In particular, a need still exists for a capability that facilitates the debugging of a transaction across multiple processors without predefining the path of the transaction. A yet further need exists for a capability that facilitates the debugging of a transaction across multiple processors without requiring a debug registration process to be performed on each processor in which the transaction is to be run and debugged.